package cn.edu.qvtu.util;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import java.lang.reflect.Field;
import java.sql.*;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.atomic.AtomicReference;

/**
 * 数据库帮助类（完整版）
 */
public class DBHelper {
    private static String driver = "com.mysql.cj.jdbc.Driver";// 驱动类完整名称
    private static String url = "jdbc:mysql://localhost:3306/classmoneydb";// 数据库连接地址
    private static String username = "root";// 数据库登录用户名
    private static String password = "root";// 数据库登录密码

    // 在静态代码块中加载数据库驱动（只执行一次）
    static {
        try {
            Class.forName(driver);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }

    /**
     * 字段说明
     */
    @Retention(RetentionPolicy.RUNTIME)
    public @interface Column {
        /**
         * 列名称
         *
         * @return 默认空，使用字段名
         */
        String name() default "";

        /**
         * 是否忽略
         *
         * @return 默认false
         */
        boolean ignore() default false;

        /**
         * 是否设置为null
         *
         * @return 默认true
         */
        boolean isSetNull() default true;
    }

    /**
     * 处理结果集接口
     */
    public interface RenderData {
        void setData(ResultSet rs) throws SQLException, InstantiationException, IllegalAccessException;
    }

    /**
     * 原子类
     *
     * @param <T> 对象类型
     */
    public static class AtomValue<T> {
        private T value;

        public T get() {
            return value;
        }

        public void set(T value) {
            this.value = value;
        }
    }

    /**
     * 获得值
     *
     * @param clazz 对象类型
     * @param map   键值对集合
     * @param keys  列名称
     * @param <T>   对象类型
     * @return 值
     */
    public static <T> T getValue(Class<T> clazz, Map<String, Object> map, String keys) {
        Object obj = map.get(keys);
        if (obj == null) {
            return null;
        }
        return (T) obj;
    }

    /**
     * 执行查询语句，处理结果集
     *
     * @param renderData 处理结果集
     * @param sql        查询语句
     * @param params     ?占位符参数值
     */
    public static void executeQuery(RenderData renderData, String sql, Object... params) {
        Connection connection = null;
        PreparedStatement preparedStatement = null;
        ResultSet rs = null;
        try {
            connection = getConnection();
            preparedStatement = connection.prepareStatement(sql);
            setParams(preparedStatement, params);
            rs = preparedStatement.executeQuery();
            renderData.setData(rs);
        } catch (SQLException | InstantiationException | IllegalAccessException e) {
            e.printStackTrace();
        } finally {
            close(connection, preparedStatement, rs);
        }
    }

    /**
     * 将结果集转化成Map
     *
     * @param rs 结果集
     * @return Map
     */
    private static Map<String, Object> getMap(ResultSet rs) throws SQLException {
        //获得 rs中的列名称
        Map<String, Object> map = new HashMap<>();
        ResultSetMetaData metaData = rs.getMetaData();
        int columnCount = metaData.getColumnCount();
        for (int i = 1; i <= columnCount; i++) {
            String columnName = metaData.getColumnName(i);
            map.put(columnName, rs.getObject(columnName));
        }
        return map;
    }

    /**
     * 执行查询语句，得到第一行数据
     *
     * @param sql    查询语句
     * @param params ?占位符参数值
     * @return Map
     */
    public static Map<String, Object> getMap(String sql, Object... params) {
        AtomValue<Map<String, Object>> map = new AtomValue<>();
        executeQuery((rs) -> {
            if (rs.next()) {
                map.set(getMap(rs));
            }
        }, sql, params);
        return map.get();
    }

    /**
     * 执行查询语句，得到所有数据
     *
     * @param sql    查询语句
     * @param params ?占位符参数值
     * @return List
     */
    public static List<Map<String, Object>> getMaps(String sql, Object... params) {
        List<Map<String, Object>> maps = new ArrayList<>();
        executeQuery((rs) -> {
            while (rs.next()) {
                maps.add(getMap(rs));
            }
        }, sql, params);
        return maps;
    }

    /**
     * 执行查询语句，得到第一行第一列数据
     *
     * @param clazz  对象类型
     * @param sql    查询语句
     * @param params ?占位符参数值
     * @param <T>    对象类型
     * @return 第一行第一列数据
     */
    public static <T> T getValue(Class<T> clazz, String sql, Object... params) {
        AtomValue<T> value = new AtomValue<>();
        executeQuery((rs) -> {
            if (rs.next()) {
                value.set((T) rs.getObject(1));
            }
        }, sql, params);
        return value.get();
    }

    /**
     * 执行查询语句，得到第一行第一列数据
     *
     * @param sql    查询语句
     * @param params ?占位符参数值
     * @return 第一行第一列数据
     */
    public static Object getValue(String sql, Object... params) {
        return getValue(Object.class, sql, params);
    }

    /**
     * 执行查询语句，得到第一行数据
     *
     * @param clazz  对象类型
     * @param sql    查询语句
     * @param params ?占位符参数值
     * @param <T>    对象类型
     * @return 对象
     */
    public static <T> T getObject(Class<T> clazz, String sql, Object... params) {
        AtomValue<T> value = new AtomValue<>();
        executeQuery((rs) -> {
            if (rs.next()) {
                value.set(getObject(clazz, rs));
            }
        }, sql, params);
        return value.get();
    }

    /**
     * 执行查询语句，得到所有数据
     *
     * @param clazz  对象类型
     * @param sql    查询语句
     * @param params ?占位符参数值
     * @param <T>    对象类型
     * @return 对象集合
     */
    public static <T> List<T> getObjects(Class<T> clazz, String sql, Object... params) {
        List<T> values = new ArrayList<>();
        executeQuery((rs) -> {
            while (rs.next()) {
                values.add(getObject(clazz, rs));
            }
        }, sql, params);
        return values;
    }

    /**
     * 将行转化成对象
     */
    private static <T> T getObject(Class<T> clazz, ResultSet rs) throws InstantiationException, IllegalAccessException, SQLException {
        //实例化T类型对象obj
        T obj = clazz.newInstance();
        //获得所有字段
        Field[] declaredFields = clazz.getDeclaredFields();
        for (Field declaredField : declaredFields) {
            //获得字段名称
            String name = declaredField.getName();
            //获得字段上的注解
            Column field = declaredField.getAnnotation(Column.class);
            boolean isSetNull = true;
            //判断注解是否为空
            if (field != null) {
                //判断注解上的name属性是否为空
                if (!field.name().equals("")) {
                    //不为空，将注解上的name属性值赋值给name
                    name = field.name();
                }
                //判断注解上的ignore属性是否为true
                if (field.ignore()) {
                    //为true，跳过当前字段
                    continue;
                }
                //判断注解上的isSetNull属性是否为true
                isSetNull = field.isSetNull();
            }

            //获得字段名称对应单元格的值
            Object object = rs.getObject(name);
            //判断单元格的值是否为空，且判断是否设置为null
            if (object == null && !isSetNull) {
                continue;
            }
            //给属性赋值
            declaredField.setAccessible(true);
            declaredField.set(obj, object);
        }
        return obj;
    }

    /**
     * 执行更新语句，返回影响行数
     *
     * @param sql    添加语句、修改语句、删除语句
     * @param params ?占位符参数值
     * @return 影响行数，-1表示执行错误
     */
    public static int executeUpdate(String sql, Object... params) {
        Connection connection = null;
        PreparedStatement preparedStatement = null;
        try {
            connection = getConnection();
            preparedStatement = connection.prepareStatement(sql);
            setParams(preparedStatement, params);
            return preparedStatement.executeUpdate();
        } catch (SQLException e) {
            e.printStackTrace();
            return -1;
        } finally {
            close(connection, preparedStatement);
        }
    }

    /**
     * 设置操作对象参数
     *
     * @param preparedStatement 操作对象
     * @param params            参数列表
     */
    public static void setParams(PreparedStatement preparedStatement, Object... params) throws SQLException {
        for (int i = 0; i < params.length; i++) {
            preparedStatement.setObject(i + 1, params[i]);
        }
    }


    /***
     * 获取数据库连接对象
     *
     * @return 数据库连接对象
     */
    public static Connection getConnection() throws SQLException {
        return DriverManager.getConnection(url, username, password);
    }

    /**
     * 关闭连接，释放资源
     *
     * @param conn 连接对象
     */
    public static void close(Connection conn) {
        if (conn != null) {
            try {
                conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 关闭连接，释放资源
     *
     * @param stmt 传输器
     */
    public static void close(Statement stmt) {
        if (stmt != null) {
            try {
                stmt.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 关闭连接，释放资源
     *
     * @param rs 结果集
     */
    public static void close(ResultSet rs) {
        if (rs != null) {
            try {
                rs.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 关闭连接，释放资源
     *
     * @param conn 连接对象
     * @param stmt 传输器
     */
    public static void close(Connection conn, Statement stmt) {
        close(stmt);
        close(conn);
    }

    /**
     * 关闭连接，释放资源
     *
     * @param conn 连接对象
     * @param stmt 传输器
     * @param rs   结果集
     */
    public static void close(Connection conn, Statement stmt, ResultSet rs) {
        close(rs);
        close(conn, stmt);
    }
}